#include "gifdec.h"
#include "../../../misc/lv_log.h"
#include "../../../misc/lv_mem.h"
#include "../../../misc/lv_color.h"
#if LV_USE_GIF

#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MIN(A, B) ((A) < (B) ? (A) : (B))
#define MAX(A, B) ((A) > (B) ? (A) : (B))

typedef struct Entry
{
    uint16_t length;
    uint16_t prefix;
    uint8_t  suffix;
} Entry;

typedef struct Table
{
    int bulk;
    int nentries;
    Entry* entries;
} Table;

static gd_GIF*   gif_open(gd_GIF* gif);
static bool f_gif_open(gd_GIF* gif, const void* path, bool is_file);
static void f_gif_read(gd_GIF* gif, void* buf, size_t len);
static int f_gif_seek(gd_GIF* gif, size_t pos, int k);
static void f_gif_close(gd_GIF* gif);

static uint16_t
read_num(gd_GIF* gif)
{
    uint8_t bytes[2];

    f_gif_read(gif, bytes, 2);
    return bytes[0] + (((uint16_t) bytes[1]) << 8);
}



gd_GIF*
gd_open_gif_file(const char* fname)
{
    gd_GIF gif_base;
    memset(&gif_base, 0, sizeof(gif_base));

    bool res = f_gif_open(&gif_base, fname, true);

    if (!res)
    {
        return NULL;
    }

    return gif_open(&gif_base);
}


gd_GIF*
gd_open_gif_data(const void* data)
{
    gd_GIF gif_base;
    memset(&gif_base, 0, sizeof(gif_base));

    bool res = f_gif_open(&gif_base, data, false);

    if (!res)
    {
        return NULL;
    }

    return gif_open(&gif_base);
}

static gd_GIF* gif_open(gd_GIF* gif_base)
{
    uint8_t sigver[3];
    uint16_t width, height, depth;
    uint8_t fdsz, bgidx, aspect;
    int i;
    uint8_t* bgcolor;
    int gct_sz;
    gd_GIF* gif = NULL;

    /* Header */
    f_gif_read(gif_base, sigver, 3);

    if (memcmp(sigver, "GIF", 3) != 0)
    {
        LV_LOG_WARN("invalid signature\n");
        goto fail;
    }

    /* Version */
    f_gif_read(gif_base, sigver, 3);

    if (memcmp(sigver, "89a", 3) != 0)
    {
        LV_LOG_WARN("invalid version\n");
        goto fail;
    }

    /* Width x Height */
    width  = read_num(gif_base);
    height = read_num(gif_base);
    /* FDSZ */
    f_gif_read(gif_base, &fdsz, 1);

    /* Presence of GCT */
    if (!(fdsz & 0x80))
    {
        LV_LOG_WARN("no global color table\n");
        goto fail;
    }

    /* Color Space's Depth */
    depth = ((fdsz >> 4) & 7) + 1;
    /* Ignore Sort Flag. */
    /* GCT Size */
    gct_sz = 1 << ((fdsz & 0x07) + 1);
    /* Background Color Index */
    f_gif_read(gif_base, &bgidx, 1);
    /* Aspect Ratio */
    f_gif_read(gif_base, &aspect, 1);
    /* Create gd_GIF Structure. */
#if LV_COLOR_DEPTH == 32
    gif = lv_mem_alloc(sizeof(gd_GIF) + 5 * width * height);
#elif LV_COLOR_DEPTH == 16
    gif = lv_mem_alloc(sizeof(gd_GIF) + 4 * width * height);
#elif LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
    gif = lv_mem_alloc(sizeof(gd_GIF) + 3 * width * height);
#endif

    if (!gif)
    {
        goto fail;
    }

    memcpy(gif, gif_base, sizeof(gd_GIF));
    gif->width  = width;
    gif->height = height;
    gif->depth  = depth;
    /* Read GCT */
    gif->gct.size = gct_sz;
    f_gif_read(gif, gif->gct.colors, 3 * gif->gct.size);
    gif->palette = &gif->gct;
    gif->bgindex = bgidx;
    gif->canvas = (uint8_t*) &gif[1];
#if LV_COLOR_DEPTH == 32
    gif->frame = &gif->canvas[4 * width * height];
#elif LV_COLOR_DEPTH == 16
    gif->frame = &gif->canvas[3 * width * height];
#elif LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
    gif->frame = &gif->canvas[2 * width * height];
#endif

    if (gif->bgindex)
    {
        memset(gif->frame, gif->bgindex, gif->width * gif->height);
    }

    bgcolor = &gif->palette->colors[gif->bgindex * 3];

    for (i = 0; i < gif->width * gif->height; i++)
    {
#if LV_COLOR_DEPTH == 32
        gif->canvas[i * 4 + 0] = *(bgcolor + 2);
        gif->canvas[i * 4 + 1] = *(bgcolor + 1);
        gif->canvas[i * 4 + 2] = *(bgcolor + 0);
        gif->canvas[i * 4 + 3] = 0xff;
#elif LV_COLOR_DEPTH == 16
        lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
        gif->canvas[i * 3 + 0] = c.full & 0xff;
        gif->canvas[i * 3 + 1] = (c.full >> 8) & 0xff;
        gif->canvas[i * 3 + 2] = 0xff;
#elif LV_COLOR_DEPTH == 8
        lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
        gif->canvas[i * 2 + 0] = c.full;
        gif->canvas[i * 2 + 1] = 0xff;
#elif LV_COLOR_DEPTH == 1
        lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
        gif->canvas[i * 2 + 0] = c.ch.red > 128 ? 1 : 0;
        gif->canvas[i * 2 + 1] = 0xff;
#endif
    }

    gif->anim_start = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
    gif->loop_count = -1;
    goto ok;
fail:
    f_gif_close(gif_base);
ok:
    return gif;
}

static void
discard_sub_blocks(gd_GIF* gif)
{
    uint8_t size;

    do
    {
        f_gif_read(gif, &size, 1);
        f_gif_seek(gif, size, LV_FS_SEEK_CUR);
    }
    while (size);
}

static void
read_plain_text_ext(gd_GIF* gif)
{
    if (gif->plain_text)
    {
        uint16_t tx, ty, tw, th;
        uint8_t cw, ch, fg, bg;
        size_t sub_block;
        f_gif_seek(gif, 1, LV_FS_SEEK_CUR); /* block size = 12 */
        tx = read_num(gif);
        ty = read_num(gif);
        tw = read_num(gif);
        th = read_num(gif);
        f_gif_read(gif, &cw, 1);
        f_gif_read(gif, &ch, 1);
        f_gif_read(gif, &fg, 1);
        f_gif_read(gif, &bg, 1);
        sub_block = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
        gif->plain_text(gif, tx, ty, tw, th, cw, ch, fg, bg);
        f_gif_seek(gif, sub_block, LV_FS_SEEK_SET);
    }
    else
    {
        /* Discard plain text metadata. */
        f_gif_seek(gif, 13, LV_FS_SEEK_CUR);
    }

    /* Discard plain text sub-blocks. */
    discard_sub_blocks(gif);
}

static void
read_graphic_control_ext(gd_GIF* gif)
{
    uint8_t rdit;

    /* Discard block size (always 0x04). */
    f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
    f_gif_read(gif, &rdit, 1);
    gif->gce.disposal = (rdit >> 2) & 3;
    gif->gce.input = rdit & 2;
    gif->gce.transparency = rdit & 1;
    gif->gce.delay = read_num(gif);
    f_gif_read(gif, &gif->gce.tindex, 1);
    /* Skip block terminator. */
    f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
}

static void
read_comment_ext(gd_GIF* gif)
{
    if (gif->comment)
    {
        size_t sub_block = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
        gif->comment(gif);
        f_gif_seek(gif, sub_block, LV_FS_SEEK_SET);
    }

    /* Discard comment sub-blocks. */
    discard_sub_blocks(gif);
}

static void
read_application_ext(gd_GIF* gif)
{
    char app_id[8];
    char app_auth_code[3];
    uint16_t loop_count;

    /* Discard block size (always 0x0B). */
    f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
    /* Application Identifier. */
    f_gif_read(gif, app_id, 8);
    /* Application Authentication Code. */
    f_gif_read(gif, app_auth_code, 3);

    if (!strncmp(app_id, "NETSCAPE", sizeof(app_id)))
    {
        /* Discard block size (0x03) and constant byte (0x01). */
        f_gif_seek(gif, 2, LV_FS_SEEK_CUR);
        loop_count = read_num(gif);

        if (gif->loop_count < 0)
        {
            if (loop_count == 0)
            {
                gif->loop_count = 0;
            }
            else
            {
                gif->loop_count = loop_count + 1;
            }
        }

        /* Skip block terminator. */
        f_gif_seek(gif, 1, LV_FS_SEEK_CUR);
    }
    else if (gif->application)
    {
        size_t sub_block = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
        gif->application(gif, app_id, app_auth_code);
        f_gif_seek(gif, sub_block, LV_FS_SEEK_SET);
        discard_sub_blocks(gif);
    }
    else
    {
        discard_sub_blocks(gif);
    }
}

static void
read_ext(gd_GIF* gif)
{
    uint8_t label;

    f_gif_read(gif, &label, 1);

    switch (label)
    {
    case 0x01:
        read_plain_text_ext(gif);
        break;

    case 0xF9:
        read_graphic_control_ext(gif);
        break;

    case 0xFE:
        read_comment_ext(gif);
        break;

    case 0xFF:
        read_application_ext(gif);
        break;

    default:
        LV_LOG_WARN("unknown extension: %02X\n", label);
    }
}

static Table*
new_table(int key_size)
{
    int key;
    int init_bulk = MAX(1 << (key_size + 1), 0x100);
    Table* table = lv_mem_alloc(sizeof(*table) + sizeof(Entry) * init_bulk);

    if (table)
    {
        table->bulk = init_bulk;
        table->nentries = (1 << key_size) + 2;
        table->entries = (Entry*) &table[1];

        for (key = 0; key < (1 << key_size); key++)
            table->entries[key] = (Entry)
        {
            1, 0xFFF, key
        };
    }

    return table;
}

/* Add table entry. Return value:
 *  0 on success
 *  +1 if key size must be incremented after this addition
 *  -1 if could not realloc table */
static int
add_entry(Table** tablep, uint16_t length, uint16_t prefix, uint8_t suffix)
{
    Table* table = *tablep;

    if (table->nentries == table->bulk)
    {
        table->bulk *= 2;
        table = lv_mem_realloc(table, sizeof(*table) + sizeof(Entry) * table->bulk);

        if (!table)
        {
            return -1;
        }

        table->entries = (Entry*) &table[1];
        *tablep = table;
    }

    table->entries[table->nentries] = (Entry)
    {
        length, prefix, suffix
    };
    table->nentries++;

    if ((table->nentries & (table->nentries - 1)) == 0)
    {
        return 1;
    }

    return 0;
}

static uint16_t
get_key(gd_GIF* gif, int key_size, uint8_t* sub_len, uint8_t* shift,
        uint8_t* byte)
{
    int bits_read;
    int rpad;
    int frag_size;
    uint16_t key;

    key = 0;

    for (bits_read = 0; bits_read < key_size; bits_read += frag_size)
    {
        rpad = (*shift + bits_read) % 8;

        if (rpad == 0)
        {
            /* Update byte. */
            if (*sub_len == 0)
            {
                f_gif_read(gif, sub_len, 1); /* Must be nonzero! */

                if (*sub_len == 0)
                {
                    return 0x1000;
                }
            }

            f_gif_read(gif, byte, 1);
            (*sub_len)--;
        }

        frag_size = MIN(key_size - bits_read, 8 - rpad);
        key |= ((uint16_t) ((*byte) >> rpad)) << bits_read;
    }

    /* Clear extra bits to the left. */
    key &= (1 << key_size) - 1;
    *shift = (*shift + key_size) % 8;
    return key;
}

/* Compute output index of y-th input line, in frame of height h. */
static int
interlaced_line_index(int h, int y)
{
    int p; /* number of lines in current pass */

    p = (h - 1) / 8 + 1;

    if (y < p) /* pass 1 */
    {
        return y * 8;
    }

    y -= p;
    p = (h - 5) / 8 + 1;

    if (y < p) /* pass 2 */
    {
        return y * 8 + 4;
    }

    y -= p;
    p = (h - 3) / 4 + 1;

    if (y < p) /* pass 3 */
    {
        return y * 4 + 2;
    }

    y -= p;
    /* pass 4 */
    return y * 2 + 1;
}

/* Decompress image pixels.
 * Return 0 on success or -1 on out-of-memory (w.r.t. LZW code table). */
static int
read_image_data(gd_GIF* gif, int interlace)
{
    uint8_t sub_len, shift, byte;
    int init_key_size, key_size, table_is_full = 0;
    int frm_off, frm_size, str_len = 0, i, p, x, y;
    uint16_t key, clear, stop;
    int ret;
    Table* table;
    Entry entry = {0};
    size_t start, end;

    f_gif_read(gif, &byte, 1);
    key_size = (int) byte;
    start = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
    discard_sub_blocks(gif);
    end = f_gif_seek(gif, 0, LV_FS_SEEK_CUR);
    f_gif_seek(gif, start, LV_FS_SEEK_SET);
    clear = 1 << key_size;
    stop = clear + 1;
    table = new_table(key_size);
    key_size++;
    init_key_size = key_size;
    sub_len = shift = 0;
    key = get_key(gif, key_size, &sub_len, &shift, &byte); /* clear code */
    frm_off = 0;
    ret = 0;
    frm_size = gif->fw * gif->fh;

    while (frm_off < frm_size)
    {
        if (key == clear)
        {
            key_size = init_key_size;
            table->nentries = (1 << (key_size - 1)) + 2;
            table_is_full = 0;
        }
        else if (!table_is_full)
        {
            ret = add_entry(&table, str_len + 1, key, entry.suffix);

            if (ret == -1)
            {
                lv_mem_free(table);
                return -1;
            }

            if (table->nentries == 0x1000)
            {
                ret = 0;
                table_is_full = 1;
            }
        }

        key = get_key(gif, key_size, &sub_len, &shift, &byte);

        if (key == clear)
        {
            continue;
        }

        if (key == stop || key == 0x1000)
        {
            break;
        }

        if (ret == 1)
        {
            key_size++;
        }

        entry = table->entries[key];
        str_len = entry.length;

        for (i = 0; i < str_len; i++)
        {
            p = frm_off + entry.length - 1;
            x = p % gif->fw;
            y = p / gif->fw;

            if (interlace)
            {
                y = interlaced_line_index((int) gif->fh, y);
            }

            gif->frame[(gif->fy + y) * gif->width + gif->fx + x] = entry.suffix;

            if (entry.prefix == 0xFFF)
            {
                break;
            }
            else
            {
                entry = table->entries[entry.prefix];
            }
        }

        frm_off += str_len;

        if (key < table->nentries - 1 && !table_is_full)
        {
            table->entries[table->nentries - 1].suffix = entry.suffix;
        }
    }

    lv_mem_free(table);

    if (key == stop)
    {
        f_gif_read(gif, &sub_len, 1);    /* Must be zero! */
    }

    f_gif_seek(gif, end, LV_FS_SEEK_SET);
    return 0;
}

/* Read image.
 * Return 0 on success or -1 on out-of-memory (w.r.t. LZW code table). */
static int
read_image(gd_GIF* gif)
{
    uint8_t fisrz;
    int interlace;

    /* Image Descriptor. */
    gif->fx = read_num(gif);
    gif->fy = read_num(gif);
    gif->fw = read_num(gif);
    gif->fh = read_num(gif);
    f_gif_read(gif, &fisrz, 1);
    interlace = fisrz & 0x40;

    /* Ignore Sort Flag. */
    /* Local Color Table? */
    if (fisrz & 0x80)
    {
        /* Read LCT */
        gif->lct.size = 1 << ((fisrz & 0x07) + 1);
        f_gif_read(gif, gif->lct.colors, 3 * gif->lct.size);
        gif->palette = &gif->lct;
    }
    else
    {
        gif->palette = &gif->gct;
    }

    /* Image Data. */
    return read_image_data(gif, interlace);
}

static void
render_frame_rect(gd_GIF* gif, uint8_t* buffer)
{
    int i, j, k;
    uint8_t index, *color;
    i = gif->fy * gif->width + gif->fx;

    for (j = 0; j < gif->fh; j++)
    {
        for (k = 0; k < gif->fw; k++)
        {
            index = gif->frame[(gif->fy + j) * gif->width + gif->fx + k];
            color = &gif->palette->colors[index * 3];

            if (!gif->gce.transparency || index != gif->gce.tindex)
            {
#if LV_COLOR_DEPTH == 32
                buffer[(i + k) * 4 + 0] = *(color + 2);
                buffer[(i + k) * 4 + 1] = *(color + 1);
                buffer[(i + k) * 4 + 2] = *(color + 0);
                buffer[(i + k) * 4 + 3] = 0xFF;
#elif LV_COLOR_DEPTH == 16
                lv_color_t c = lv_color_make(*(color + 0), *(color + 1), *(color + 2));
                buffer[(i + k) * 3 + 0] = c.full & 0xff;
                buffer[(i + k) * 3 + 1] = (c.full >> 8) & 0xff;
                buffer[(i + k) * 3 + 2] = 0xff;
#elif LV_COLOR_DEPTH == 8
                lv_color_t c = lv_color_make(*(color + 0), *(color + 1), *(color + 2));
                buffer[(i + k) * 2 + 0] = c.full;
                buffer[(i + k) * 2 + 1] = 0xff;
#elif LV_COLOR_DEPTH == 1
                uint8_t b = (*(color + 0)) | (*(color + 1)) | (*(color + 2));
                buffer[(i + k) * 2 + 0] = b > 128 ? 1 : 0;
                buffer[(i + k) * 2 + 1] = 0xff;
#endif
            }
        }

        i += gif->width;
    }
}

static void
dispose(gd_GIF* gif)
{
    int i, j, k;
    uint8_t* bgcolor;

    switch (gif->gce.disposal)
    {
    case 2: /* Restore to background color. */
        bgcolor = &gif->palette->colors[gif->bgindex * 3];

        uint8_t opa = 0xff;

        if (gif->gce.transparency)
        {
            opa = 0x00;
        }

        i = gif->fy * gif->width + gif->fx;

        for (j = 0; j < gif->fh; j++)
        {
            for (k = 0; k < gif->fw; k++)
            {
#if LV_COLOR_DEPTH == 32
                gif->canvas[(i + k) * 4 + 0] = *(bgcolor + 2);
                gif->canvas[(i + k) * 4 + 1] = *(bgcolor + 1);
                gif->canvas[(i + k) * 4 + 2] = *(bgcolor + 0);
                gif->canvas[(i + k) * 4 + 3] = opa;
#elif LV_COLOR_DEPTH == 16
                lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
                gif->canvas[(i + k) * 3 + 0] = c.full & 0xff;
                gif->canvas[(i + k) * 3 + 1] = (c.full >> 8) & 0xff;
                gif->canvas[(i + k) * 3 + 2] = opa;
#elif LV_COLOR_DEPTH == 8
                lv_color_t c = lv_color_make(*(bgcolor + 0), *(bgcolor + 1), *(bgcolor + 2));
                gif->canvas[(i + k) * 2 + 0] = c.full;
                gif->canvas[(i + k) * 2 + 1] = opa;
#elif LV_COLOR_DEPTH == 1
                uint8_t b = (*(bgcolor + 0)) | (*(bgcolor + 1)) | (*(bgcolor + 2));
                gif->canvas[(i + k) * 2 + 0] = b > 128 ? 1 : 0;
                gif->canvas[(i + k) * 2 + 1] = opa;
#endif
            }

            i += gif->width;
        }

        break;

    case 3: /* Restore to previous, i.e., don't update canvas.*/
        break;

    default:
        /* Add frame non-transparent pixels to canvas. */
        render_frame_rect(gif, gif->canvas);
    }
}

/* Return 1 if got a frame; 0 if got GIF trailer; -1 if error. */
int
gd_get_frame(gd_GIF* gif)
{
    char sep;

    dispose(gif);
    f_gif_read(gif, &sep, 1);

    while (sep != ',')
    {
        if (sep == ';')
        {
            f_gif_seek(gif, gif->anim_start, LV_FS_SEEK_SET);

            if (gif->loop_count == 1 || gif->loop_count < 0)
            {
                return 0;
            }
            else if (gif->loop_count > 1)
            {
                gif->loop_count--;
            }
        }
        else if (sep == '!')
        {
            read_ext(gif);
        }
        else
        {
            return -1;
        }

        f_gif_read(gif, &sep, 1);
    }

    if (read_image(gif) == -1)
    {
        return -1;
    }

    return 1;
}

void
gd_render_frame(gd_GIF* gif, uint8_t* buffer)
{
//    uint32_t i;
//    uint32_t j;
//    for(i = 0, j = 0; i < gif->width * gif->height * 3; i+= 3, j+=4) {
//        buffer[j + 0] = gif->canvas[i + 2];
//        buffer[j + 1] = gif->canvas[i + 1];
//        buffer[j + 2] = gif->canvas[i + 0];
//        buffer[j + 3] = 0xFF;
//    }
//    memcpy(buffer, gif->canvas, gif->width * gif->height * 3);
    render_frame_rect(gif, buffer);
}

void
gd_rewind(gd_GIF* gif)
{
    gif->loop_count = -1;
    f_gif_seek(gif, gif->anim_start, LV_FS_SEEK_SET);
}

void
gd_close_gif(gd_GIF* gif)
{
    f_gif_close(gif);
    lv_mem_free(gif);
}

static bool f_gif_open(gd_GIF* gif, const void* path, bool is_file)
{
    gif->f_rw_p = 0;
    gif->data = NULL;
    gif->is_file = is_file;

    if (is_file)
    {
        lv_fs_res_t res = lv_fs_open(&gif->fd, path, LV_FS_MODE_RD);

        if (res != LV_FS_RES_OK)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    else
    {
        gif->data = path;
        return true;
    }
}

static void f_gif_read(gd_GIF* gif, void* buf, size_t len)
{
    if (gif->is_file)
    {
        lv_fs_read(&gif->fd, buf, len, NULL);
    }
    else
    {
        memcpy(buf, &gif->data[gif->f_rw_p], len);
        gif->f_rw_p += len;
    }
}

static int f_gif_seek(gd_GIF* gif, size_t pos, int k)
{
    if (gif->is_file)
    {
        lv_fs_seek(&gif->fd, pos, k);
        uint32_t x;
        lv_fs_tell(&gif->fd, &x);
        return x;
    }
    else
    {
        if (k == LV_FS_SEEK_CUR)
        {
            gif->f_rw_p += pos;
        }
        else if (k == LV_FS_SEEK_SET)
        {
            gif->f_rw_p = pos;
        }

        return gif->f_rw_p;
    }
}

static void f_gif_close(gd_GIF* gif)
{
    if (gif->is_file)
    {
        lv_fs_close(&gif->fd);
    }
}

#endif /*LV_USE_GIF*/
